package com.example.learnjava.exception;

/**
 * 按java规范书写程序代码，如果你认为程序有错误，请指出，并说明程序错误原因。
 */

public class I_pracetise_123 {

    /****************第1题***************************/
   /* public static void func(){
        try {
            throw new Exception();
        }finally {
            System.out.println("B");
        }
    }

    public static void main(String[] args) {
        try {
            func();
            System.out.println("A");
        }catch (Exception e){
            System.out.println("C");
        }
        System.out.println("D");
    }*/

    //答案：编译失败。如果func放上声明了该异常，结果是BCD。
    /****************第1题***************************/

    /****************第2题***************************/
    /*class Test{
        public Test() {
            System.out.println("Test");
        }
    }

    class Demo extends Test{

        public Demo() {
            super();
            System.out.println("Demo");
        }

        public static void main(String[] args) {
            new Demo();
            new Test();
        }
    }*/
    //答案：
    //Test
    //Demo
    //Test
    /****************第2题***************************/


    /****************第3题***************************/
    //写出程序结果
  /*  interface A{}
    class B implements A{
        public String func(){
            return "func";
        }
    }

    class Demo{
        public static void main(String[] args) {
            A a=new B();
            System.out.println(a.func());
        }
    }*/
    //答案：编译失败，因为A接口中并未定义func方法。
    /****************第3题***************************/

    /****************第4题***************************/
    //写出程序结果
   /* class Fu{
        boolean show(char a){
            System.out.println(a);
            return true;
        }
    }

    class Demo extends Fu{
        public static void main(String[] args) {
            int i=0;
            Fu f=new Demo();
            Demo d=new Demo();
            for (f.show('A');f.show('B')&& (i<2);f.show('C')){
                i++;
                d.show('D');
            }
        }
        boolean show(char a){
            System.out.println(a);
            return false;
        }
    }*/
    //答案：A B。因为f.show()调用的是子类方法。编译看左边，运行看右边。
    /****************第4题***************************/

    /****************第5题***************************/
    //写出程序结果
    /*interface A{}
    class B implements A{
        public String test(){
            return "yes";
        }
    }
    class Demo{
        static A get(){
            return new B();
        }

        public static void main(String[] args) {
            A a=get();
            System.out.println(a.test());
        }
    }*/

    //  答案：编译失败。因为A接口中没有定义Test方法。
    /****************第5题***************************/

    /****************第6题***************************/
    //写出程序结果
    /*class Super {
        int i = 0;

        public Super(String a) {
            System.out.println("A");
        }

        public Super() {
            System.out.println("B");
            i += 2;
        }
    }
    class Demo extends Super{
        public Demo(String a) {
            System.out.println("C");
            i=5;
        }

        public static void main(String[] args) {
            int i=4;
            Super d=new Demo("A");
            System.out.println(d.i);
        }
    }*/
//    答案： B
//          C
//          5
    /****************第6题***************************/

    /****************第7题***************************/
    interface Inter {
        void show(int a, int b);

        void func();
    }

    class Demo {
        public static void main(String[] args) {
            //补足代码，调用两个函数，要求用匿名内部类

        }
    }

    //答案
//   Inter inter= new Inter() {
//        @Override
//        public void show(int a, int b) {
//
//        }
//
//        @Override
//        public void func() {
//
//        }
//    };
//    inter.show(1,2);
//    inter.func();
    /****************第7题***************************/

    /****************第8题***************************/
   /* class TD{
        int y=6;
        class Inner{
            static int y=3;
            void show(){
                System.out.println(y);
            }
        }
    }
    class TC{
        public static void main(String[] args) {
            TD.Inner ti=new TD().new Inner();
            ti.show();
        }
    }*/
    //给出的答案是：编译失败，非静态内部类中不可以定义静态成员。
    //内部类中如果定义了静态成员，该内部类必须被静态修饰。
    /****************第8题***************************/

    /****************第9题***************************/
    //选择题，写出错误答案错误的原因，用单行注释的方式。
    /*class Demo9{
        int show(int a,int b){
            return 0;
        }
    }*/
    //下面哪些函数可以存在于Demo的子类中。
//    A.public int show(int a,int b){return 0;}//可以，覆盖
//    B.private int show(int a,int b){return 0;}//不可以，权限不够
//    C.public int show(int a,long b){return 0;}//可以，和父类不是一个函数，没有覆盖，相当于重载。
//    D.public short show(int a,int b){return 0;}//不可以，因为该函数不可以和给定函数出现在同一类中，或者子父类中。
//    E.static int show(int a,int b){return 0;}//不可以，静态只能覆盖静态。
    /****************第9题***************************/

    /****************第10题***************************/
    //写出this关键字的含义，final有哪些特点？
    //    答案：
    // this代表本类对象，哪个对象调用this所在函数，this就代表哪个对象。
    // final:
    // final可以修饰类，变量（成员变量，静态变量，局部变量），函数。
    // 1.修饰的类不可以被继承。
    // 2.修饰的函数不可以被覆盖。
    // 3.修饰的变量是一个常亮，只能赋值一次。

    /****************第10题***************************/

    /****************第11题***************************/
    //写出程序结果
    /*class Fu{
        int num=4;
        void show(){
            System.out.println("shouFu");
        }
    }
    class Zi extends Fu{
        int num=5;
        void show(){
            System.out.println("showzi");
        }
    }
    class T{
        public static void main(String[] args) {
            Fu f=new Zi();
            Zi z=new Zi();
            System.out.println(f.num);
            System.out.println(z.num);
            f.show();
            z.show();
        }
    }*/
    //答案：4,5，showZi,showZi
    /****************第11题***************************/

    /****************第12题***************************/
    /*interface A{
        void show();
    }
    interface B{
        void add(int a,int b);
    }
    class C implements A,B{
        //程序代码


    }
    class D{
        public static void main(String[] args) {
            C c=new C();
            c.add(4,2);
            c.show();//通过该函数打印以上两个数的和。
        }
    }*/
    //答案：
    // int sum=0;
//    @Override
//    public void show() {
//         System.out.println(sum);
//    }
//
//    @Override
//    public void add(int a, int b) {
//          sum=a+b;
//    }
    /****************第12题***************************/

    /****************第13题***************************/
    //写出程序结果
    class Demo13 {
        public static void main(String[] args) {
            try {
                showExce();
                System.out.println("A");
            } catch (Exception e) {
                System.out.println("B");
            } finally {
                System.out.println("C");
            }
            System.out.println("D");
        }

        public static void showExce() throws Exception {
            throw new Exception();
        }
    }
    //答案：B  C  D
    /****************第13题***************************/

    /****************第14题***************************/
    //写出程序结果
   /* class Super14{
        int i=0;

        public Super14(String s) {
            this.i = 1;
        }
    }
    class Demo14 extends Super14{

        public Demo14(String s) {
            i=2;
        }

        public static void main(String[] args) {
            Demo d=new Demo("yes");
            System.out.println(d.i);
        }
    }*/
    //答案：编译失败。因为父类中缺少空参数的构造函数。
    //或者子类应该通过super语句指定要调用的父类中的构造函数。
    /****************第14题***************************/

    /****************第15题***************************/
    //写出程序结果
   /* class Super15{
        public int get(){
            return 4;
        }
    }
    class Demo15 extends Super15{
        public long get(){
            return 5;
        }

        public static void main(String[] args) {
            Super15 s=new Demo15();
            System.out.println(s.get());
        }
    }*/
    //编译失败，因为子父类中的get方法没有覆盖，但是子类调用时候不能明确返回的值是什么类型。
    //所以这样的函数不能存在于子父类中。
    /****************第15题***************************/

    /****************第16题***************************/
    /*class Demo16{
        public static void func(){
            try{
                throw new Exception();
                System.out.println("A");
            }catch (Exception e){
                System.out.println("B");
            }
        }

        public static void main(String[] args) {
            try{
                func();
            }catch (Exception e){
                System.out.println("C");
            }
            System.out.println("D");
        }
    }*/
    //答案：编译失败，因为打印”A"的输出语句执行不到。
    //记住，throw单独存在，下面不要定义语句，因为执行不到。

    /****************第16题***************************/

    /****************第17题***************************/
    /*class Demo17{
        public void func(){
            //位置1；
        }
        class Inner{}

        public static void main(String[] args) {
            Demo17 d=new Demo17();
            //位置2：
        }
    }
    A.在位置1写 new Inner();//ok
    B.在位置2写 new Inner();//不可以，因为主函数是静态的，如果访问inner需要被static修饰
    C.在位置2写 new d.Inner(); //错误，格式错误。还原后是new new Demo().Inner();
    D.在位置2写 new Demo.Inner();//错误，因为inner不是静态的。*/
    /****************第17题***************************/

    /****************第18题***************************/
    //写出程序结果
   /* class Exc0 extends Exception {
    }

    class Exc1 extends Exc0 {
    }

    class Demo18 {
        public static void main(String[] args) {
            try {
                throw new Exc1();
            } catch (Exception e) {
                System.out.println("Exception");
            } catch (Exc0 e) {
                System.out.println("Exc0");
            }
        }
    }*/
    //编译失败，因为多个catch时，父类的catch要放在下面。
    /****************第18题***************************/

    /****************第19题***************************/
   /* interface Test19{
        void func();
    }
    class Demo19{
        public static void main(String[] args) {
            //补足代码：（匿名内部类）
        }
        void show(Test19 t){
            t.func();
        }
    }
//    答案：
    new Demo19().show(new Test19(){
       public void func(){

        }
    });*/
    /****************第19题***************************/

    /****************第20题***************************/
    //写出程序结果
    class Test20 {
        public static String output = "";

        public static void foo(int i) {
            try {
                if (i == 1)
                    throw new Exception();
                output += "1";
            } catch (Exception e) {
                output += 2;
                return;
            } finally {
                output += "3";
            }
            output += "4";
        }

        public static void main(String[] args) {
            foo(0);
            System.out.println(output);
            foo(1);
            System.out.println(output);
        }
    }
    //答案：134   13423

    /****************第20题***************************/

    /****************第21题***************************/
    /**
     * 有一个圆形和长方形。
     * 都可以获取面积，对于面积如果出现非法的数值，视为是获取面积出现问题。
     * 问题通过异常来表示。
     * 现在对这个程序进行基本设计。
     */
    //见121
    /****************第21题***************************/

    /****************第22题***************************/
//    补足compare函数内的代码，不许添加其他函数。
    /*class Circle{
        private static double pi=3.14;
        private double radius;
        private Circle(double r){
            radius=r;
        }
        public static double compare(Circle[] cir){
            //程序代码,其实就是在求数组中的最大值。

        }
    }
    class TC{
        public static void main(String[] args) {
            Circle cir[] =new Circle[3];//创建了一个类类型的数组。
            cir[0]=new Circle(1.0);
            cir[1]=new Circle(2.0);
            cir[2]=new Circle(4.0);
            System.out.println("最大的半径值是:"+Circle.compare(cir));
        }
    }*/

    //答案：很多种写法，下面是其中一种：
//    int max=0;
//            for (int i = 0; i < cir.length; i++) {
//        if (cir[i].radius>cir[max].radius){
//            max=i;
//        }
//    }
//            return cir[max].radius;

    /****************第22题***************************/


    /****************第23题***************************/
    //写出程序结果
    /*public class Demo23 {
        private static int j = 0;

        private static boolean methodB(int k) {
            j += k;
            return true;
        }

        public static void methodA(int i) {
            boolean b;
            b = i < 10 | methodB(4);
            b = i < 10 || methodB(8);
        }

        public static void main(String[] args) {
            methodA(0);
            System.out.println(j);
        }
    }*/
    //答案：4
    /****************第23题***************************/

    /****************第24题***************************/
    /**
     * 假如我们在开发一个系统时需要对员工进行建模，员工包含3个属性：姓名、工号、以及工资。
     * 经理也是员工，除了含有员工的属性外，另外还有一个奖金属性。请使用继承的思想设计处员工类
     * 和经理类。要求类中提供必要的方法进行属性访问。
     */
    /****************第24题***************************/

    /****************第25题***************************/
    /**
     * 在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，如果存在，
     * 则返回这个字符数组中第一次出现的位置（序号从0开始计算），否则，返回-1。要搜索的字符数组和字符
     * 都以参数形式传递给该方法，如果传入的数组为null，应抛出IllegalArgumentException异常。
     * 在类的main方法中以各种可能出现的情况测试试验该方法编写的是否正确。
     * 例如：字符不存在，字符存在，传入的数组为null等。
     */
   /* public int getIndex(char[] arr,char key){
        if (arr==null){
            throw new IllegalArgumentException("数组为null");
        }
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]==key){
                return i;
            }
        }
        return -1;
    }*/
    /****************第25题***************************/

    /****************第26题***************************/
    //补足compare函数内的代码，不许添加其他函数。
   /* class Circle{
        private double radius;

        public Circle(double r) {
            this.radius = r;
        }
        public Circle compare(Circle cir){
            //程序代码

        }

    }
    class TC{
        public static void main(String[] args) {
            Circle cir1=new Circle(1.0);
            Circle cir2=new Circle(2.0);
            Circle cir;
            cir=cir1.compare(cir2);
            if (cir1==cir){
                System.out.println("圆1的半径比较大");
            }else{
                System.out.println("圆2的半径比较大");
            }
        }
    }*/

    //答案：
//     if (this.radius>cir.radius){
//        return this;
//    }else {
//        return cir;
//    }
//
//     或者
//    return this.radius>cir.radius?this:cir;


    /****************第26题***************************/


}
